const { uniModal } = require('../../utils/util');
const DeviceManager = require('../../NFCApi/DeviceManager');
const TextEncoder = require('../../NFCApi/Encoder');
const { Result, Ctrl } = require('../../NFCApi/E');

Page({
  data: {
    controlType: null,
    deviceConnected: false,
    deviceInfo: null,
    chargeLevel: null,
    message: '',
    password: '20250624', // 默认密码，实际应用中应从安全存储或用户输入获取
    isProcessing: false,
    // 新增状态
    isUnlocked: false,
    showBatteryAnimation: false,
    batteryAnimationFrame: 0,
    batteryAnimationInterval: null,
    nfcEnabled: false, // 新增NFC开启状态
    nfcCheckInterval: null // NFC状态检测定时器
  },

  onLoad: function() {
    // 页面加载时的初始化操作
    this.checkNFCAvailability();
    // 启动定时检测NFC状态
    this.startNFCStatusCheck();
  },

  onShow: function() {
    // 页面显示时启动NFC检测
    this.startNFCDiscovery();
    // 重新检查NFC状态（用户可能从设置页面返回）
    this.checkNFCAvailability();
  },

  onHide: function() {
    // 页面隐藏时停止NFC检测
    this.stopNFCDiscovery();
    // 停止NFC状态检测
    this.stopNFCStatusCheck();
  },

  checkNFCAvailability: function() {
    console.log('开始检查NFC可用性');
    
    // 检查设备是否支持NFC
    if (wx.getNFCAdapter) {
      this.adapter = wx.getNFCAdapter();
      if (!this.adapter) {
        console.log('设备不支持NFC');
        this.setData({
          message: '此设备不支持NFC功能',
          nfcEnabled: false
        });
        return;
      }
      
      // 检查是否在开发环境中
      const systemInfo = wx.getSystemInfoSync();
      console.log('系统信息:', systemInfo);
      
      if (systemInfo.platform === 'devtools') {
        console.log('检测到开发环境');
        this.setData({
          message: '开发环境不支持NFC功能，请在真机上测试',
          nfcEnabled: true // 开发环境中允许按钮可用，方便测试
        });
        return;
      }
      
      // 真机环境，先默认设置为可用，然后检查NFC状态
      this.setData({
        nfcEnabled: true,
        message: 'NFC功能正常，请点击开锁或关锁按钮'
      });
      
      // 检查NFC是否开启（异步检查，不阻塞按钮使用）
      wx.checkNFCEnabled({
        success: () => {
          console.log('NFC已开启');
          this.setData({
            message: 'NFC功能正常，请点击开锁或关锁按钮',
            nfcEnabled: true
          });
        },
        fail: (err) => {
          console.log('NFC未开启或不可用:', err);
          // 即使NFC未开启，也不禁用按钮，让用户可以尝试操作
          this.setData({
            message: '建议开启NFC功能以获得最佳体验',
            nfcEnabled: true
          });
          
          // 只在首次检测时显示弹窗提示
          if (!this.nfcCheckShown) {
            this.nfcCheckShown = true;
            // 显示开启NFC的提示
            wx.showModal({
              title: 'NFC功能未开启',
              content: '建议开启手机的NFC功能以获得最佳使用体验。',
              showCancel: true,
              cancelText: '稍后开启',
              confirmText: '去设置',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  // 尝试打开系统设置（部分手机支持）
                  wx.openSetting({
                    success: () => {
                      console.log('打开设置成功');
                    },
                    fail: () => {
                      wx.showToast({
                        title: '请手动前往设置开启NFC',
                        icon: 'none',
                        duration: 3000
                      });
                    }
                  });
                }
              }
            });
          }
        }
      });
    } else {
      console.log('不支持getNFCAdapter API');
      this.setData({
        message: '此设备不支持NFC功能',
        nfcEnabled: false
      });
    }
  },

  startNFCDiscovery: function() {
    if (!this.adapter) return;
    
    // 检查是否在开发环境中
    const systemInfo = wx.getSystemInfoSync();
    if (systemInfo.platform === 'devtools') {
      this.setData({
        message: '开发环境不支持NFC功能，请在真机上测试'
      });
      return;
    }
    
    // 停止之前的搜索
    this.stopNFCDiscovery();
    
    // 开始搜索NFC设备
    this.adapter.startDiscovery({
      success: () => {
        console.log('NFC搜索已启动');
        this.setData({
          message: 'NFC搜索已启动，请将设备靠近NFC锁...'
        });
        
        // 注册NFC发现事件
        this.adapter.onDiscovered(this.handleNFCDiscovered.bind(this));
      },
      fail: (err) => {
        console.error('NFC搜索启动失败', err);
        // 检查是否是平台不支持的错误
        if (err.errMsg && err.errMsg.includes('not supported')) {
          this.setData({
            message: '当前平台不支持NFC功能，请在支持NFC的真机上测试'
          });
        } else {
          // 移除NFC启动失败弹窗，只显示在消息区域
          this.setData({
            message: `NFC搜索启动失败: ${err.errMsg}`
          });
        }
      }
    });
  },

  // 启动NFC状态定时检测
  startNFCStatusCheck: function() {
    console.log('启动NFC状态检测');
    
    // 检查是否在开发环境中，如果是则不启动定时检测
    const systemInfo = wx.getSystemInfoSync();
    if (systemInfo.platform === 'devtools') {
      console.log('开发环境，跳过NFC状态定时检测');
      return;
    }
    
    // 清除之前的定时器
    if (this.data.nfcCheckInterval) {
      clearInterval(this.data.nfcCheckInterval);
    }
    
    // 每3秒检测一次NFC状态（降低频率，避免过于频繁）
    const interval = setInterval(() => {
      if (wx.getNFCAdapter && this.adapter) {
        wx.checkNFCEnabled({
          success: () => {
            // NFC开启时不需要特别处理，保持按钮可用
            if (this.data.message.includes('建议开启NFC')) {
              this.setData({
                message: 'NFC功能正常，请点击开锁或关锁按钮'
              });
            }
          },
          fail: () => {
            // NFC关闭时也不禁用按钮，只更新提示信息
            if (!this.data.message.includes('建议开启NFC')) {
              this.setData({
                message: '建议开启NFC功能以获得最佳体验'
              });
            }
          }
        });
      }
    }, 3000); // 改为3秒检测一次
    
    this.setData({
      nfcCheckInterval: interval
    });
  },

  // 停止NFC状态检测
  stopNFCStatusCheck: function() {
    if (this.data.nfcCheckInterval) {
      clearInterval(this.data.nfcCheckInterval);
      this.setData({
        nfcCheckInterval: null
      });
    }
  },

  stopNFCDiscovery: function() {
    if (this.adapter) {
      try {
        this.adapter.stopDiscovery();
        console.log('NFC搜索已停止');
      } catch (e) {
        console.error('停止NFC搜索时出错', e);
      }
    }
  },

  onUnlock: function() {
    if (this.data.isProcessing) {
      uniModal('操作正在进行中，请稍候...');
      return;
    }
    
    this.setData({
      controlType: Ctrl.UNLOCK,
      message: '请将手机靠近NFC锁进行开锁...'
    });
  },

  onLock: function() {
    if (this.data.isProcessing) {
      uniModal('操作正在进行中，请稍候...');
      return;
    }
    
    this.setData({
      controlType: Ctrl.LOCK,
      message: '请将手机靠近NFC锁进行关锁...'
    });
  },

  // NFC设备发现处理
  handleNFCDiscovered: function(res) {
    const ctrl = this.data.controlType;
    
    if (!ctrl) {
      this.setData({
        message: '已检测到NFC设备，请点击开锁或关锁按钮'
      });
      return;
    }

    // 标记开始处理
    this.setData({
      isProcessing: true,
      message: '正在连接NFC设备...'
    });

    // 获取NFC-A类型的标签
    const nfcA = this.adapter.getNfcA();
    
    // 连接NFC标签
    nfcA.connect({
      success: async () => {
        this.setData({
          deviceConnected: true,
          message: 'NFC设备已连接，正在处理...'
        });
        
        try {
          await this.processNFCDevice(nfcA, ctrl);
        } catch (error) {
          console.error('处理NFC设备时出错', error);
          uniModal(`处理NFC设备时出错: ${error.message || '未知错误'}`);
          this.setData({
            message: `处理NFC设备时出错: ${error.message || '未知错误'}`,
            isProcessing: false
          });
        }
      },
      fail: (err) => {
        console.error('NFC连接失败', err);
        // 移除弹窗提示，只在控制台记录错误
        this.setData({
          message: `NFC连接失败: ${err.errMsg}`,
          isProcessing: false,
          controlType: null
        });
      }
    });
  },



  // 处理NFC设备
  processNFCDevice: async function(nfcA, ctrl) {
    // transceive 函数用于发送数据并接收响应
    const transceive = (data) => {
      return new Promise((resolve) => {
        nfcA.transceive({
          data: data.buffer,
          success: (res) => {
            resolve(new Uint8Array(res.data));
          },
          fail: (err) => {
            console.error('数据传输失败', err);
            resolve(new Uint8Array([]));
          }
        });
      });
    };
    
    // 初始化设备
    this.setData({ message: '初始化设备中...' });
    const [result1, device] = await DeviceManager.init({ transceive });
    
    // 初始化失败
    if (result1 !== Result.OK || !device) {
      this.setData({
        message: '设备初始化失败',
        isProcessing: false,
        controlType: null
      });
      // 移除弹窗提示
      return;
    }

    // 获取设备信息
    this.setData({ message: '获取设备信息中...' });
    const [result2, info] = await DeviceManager.getInfo({ transceive }, device);
    
    // 获取设备信息失败
    if (result2 !== Result.OK || !info) {
      this.setData({
        message: '获取设备信息失败',
        isProcessing: false,
        controlType: null
      });
      // 移除弹窗提示
      return;
    }

    // 创建一个可序列化的设备信息对象(将BigInt转为字符串)
    const serializableInfo = {
      id: info.id.toString(),
      isNew: info.isNew
    };

    // 显示设备信息
    this.setData({
      deviceInfo: serializableInfo,
      message: `设备ID: ${serializableInfo.id}, 是否新设备: ${serializableInfo.isNew ? '是' : '否'}`
    });

    // 加密密钥 (使用原始info对象，因为需要原始BigInt)
    const passwordBytes = new TextEncoder().encode(this.data.password.padEnd(16, "\0"));
    const key = DeviceManager.enc(passwordBytes, info);

    // 轮询设备充电进度
    let controlSuccessful = false;
    
    // 启动充电动画
    this.setData({ 
      showBatteryAnimation: true,
      chargeLevel: 0 
    });
    this.startBatteryAnimation();
    
    for (let t = 1; t <= 40; t++) {
      // 获取充电进度
      this.setData({ message: `检查充电进度 (${t}/40)...` });
      const [result3, level] = await DeviceManager.getChargeLevel({ transceive }, device, key);
      
      if (result3 === Result.OK && level) {
        // 更新充电进度并实时绘制
        const currentLevel = Math.min(level.level, 100); // 限制最大值为100
        this.setData({ chargeLevel: currentLevel });
        this.drawBatteryCircle(currentLevel);
        
        // 充电完成
        if (level.complete) {
          // 控制设备
          this.setData({ 
            message: ctrl.value === Ctrl.UNLOCK.value ? '正在开锁...' : '正在关锁...'
          });
          
          const result4 = await DeviceManager.control({ transceive }, device, key, ctrl);
          
          // 控制设备成功
          if (result4 === Result.OK) {
            controlSuccessful = true;
            // 修复：比较value属性而不是对象本身
            const isUnlocked = ctrl.value === Ctrl.UNLOCK.value;
            
            // 更新UI状态
            this.setData({
              isUnlocked: isUnlocked,
              message: isUnlocked ? '开锁成功！' : '关锁成功！',
              controlType: null,
              isProcessing: false
            });
            
            // 不再重复启动动画，因为已经在充电过程中显示了
            
            const successMessage = ctrl.value === Ctrl.UNLOCK.value ? '开锁成功！' : '关锁成功！';
            uniModal(successMessage);
            break;
          } else {
            this.setData({
              message: ctrl.value === Ctrl.UNLOCK.value ? '开锁失败' : '关锁失败',
              isProcessing: false,
              controlType: null
            });
            // 移除失败弹窗提示
            break;
          }
        } else {
          // 等待充电完成
          await new Promise(resolve => setTimeout(resolve, 100));
        }
      } else {
        this.setData({
          message: '获取充电进度失败',
          isProcessing: false,
          controlType: null
        });
        // 移除失败弹窗提示
        break;
    }
  }

  // 如果所有轮询都未成功
  if (!controlSuccessful) {
    this.setData({
      message: '设备充电未完成或操作超时',
      controlType: null,
      isProcessing: false
    });
  }
},

// 绘制电量圆环动画
drawBatteryCircle: function(progress) {
  const query = wx.createSelectorQuery().in(this);
  query.select('#batteryCanvas')
    .fields({ node: true, size: true })
    .exec((res) => {
      if (!res[0]) return;
      
      const canvas = res[0].node;
      const ctx = canvas.getContext('2d');
      
      const dpr = wx.getSystemInfoSync().pixelRatio;
      canvas.width = res[0].width * dpr;
      canvas.height = res[0].height * dpr;
      ctx.scale(dpr, dpr);
      
      const width = res[0].width;
      const height = res[0].height;
      const centerX = width / 2;
      const centerY = height / 2;
      const radius = (Math.min(width, height) - 20) / 2;
      const lineWidth = 12;
      
      // 清除画布
      ctx.clearRect(0, 0, width, height);
      
      // 绘制底色圆环
      ctx.beginPath();
      ctx.arc(centerX, centerY, radius, 0, 2 * Math.PI);
      ctx.lineWidth = lineWidth;
      ctx.strokeStyle = '#f0f0f0';
      ctx.stroke();
      
      // 绘制进度圆环
      if (progress > 0) {
        const startAngle = -0.5 * Math.PI;
        const endAngle = startAngle + (progress / 100) * 2 * Math.PI;
        
        ctx.beginPath();
        ctx.arc(centerX, centerY, radius, startAngle, endAngle);
        ctx.lineWidth = lineWidth;
        
        // 根据进度设置颜色
        let strokeColor;
        if (progress < 30) {
          strokeColor = '#ff3b30';
        } else if (progress < 70) {
          strokeColor = '#ffcc00';
        } else {
          strokeColor = '#4cd964';
        }
        
        ctx.strokeStyle = strokeColor;
        ctx.lineCap = 'round';
        ctx.stroke();
      }
    });
},

// 启动电量动画
startBatteryAnimation: function() {
  console.log('启动电量动画，当前电量:', this.data.chargeLevel);
  
  // 清除之前的动画
  if (this.data.batteryAnimationInterval) {
    clearInterval(this.data.batteryAnimationInterval);
  }
  
  // 等待DOM更新后再开始绘制
  setTimeout(() => {
    // 绘制初始状态
    this.drawBatteryCircle(0);
  }, 100);
}
});